home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / mips / include / asm / pgtable.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  10.5 KB  |  384 lines
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * Copyright (C) 2003 Ralf Baechle
  7.  */
  8. #ifndef _ASM_PGTABLE_H
  9. #define _ASM_PGTABLE_H
  10.  
  11. #ifdef CONFIG_32BIT
  12. #include <asm/pgtable-32.h>
  13. #endif
  14. #ifdef CONFIG_64BIT
  15. #include <asm/pgtable-64.h>
  16. #endif
  17.  
  18. #include <asm/io.h>
  19. #include <asm/pgtable-bits.h>
  20.  
  21. struct mm_struct;
  22. struct vm_area_struct;
  23.  
  24. #define PAGE_NONE    __pgprot(_PAGE_PRESENT | _CACHE_CACHABLE_NONCOHERENT)
  25. #define PAGE_SHARED    __pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \
  26.                  _page_cachable_default)
  27. #define PAGE_COPY    __pgprot(_PAGE_PRESENT | _PAGE_READ | \
  28.                  _page_cachable_default)
  29. #define PAGE_READONLY    __pgprot(_PAGE_PRESENT | _PAGE_READ | \
  30.                  _page_cachable_default)
  31. #define PAGE_KERNEL    __pgprot(_PAGE_PRESENT | __READABLE | __WRITEABLE | \
  32.                  _PAGE_GLOBAL | _page_cachable_default)
  33. #define PAGE_USERIO    __pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \
  34.                  _page_cachable_default)
  35. #define PAGE_KERNEL_UNCACHED __pgprot(_PAGE_PRESENT | __READABLE | \
  36.             __WRITEABLE | _PAGE_GLOBAL | _CACHE_UNCACHED)
  37.  
  38. /*
  39.  * MIPS can't do page protection for execute, and considers that the same like
  40.  * read. Also, write permissions imply read permissions. This is the closest
  41.  * we can get by reasonable means..
  42.  */
  43.  
  44. /*
  45.  * Dummy values to fill the table in mmap.c
  46.  * The real values will be generated at runtime
  47.  */
  48. #define __P000 __pgprot(0)
  49. #define __P001 __pgprot(0)
  50. #define __P010 __pgprot(0)
  51. #define __P011 __pgprot(0)
  52. #define __P100 __pgprot(0)
  53. #define __P101 __pgprot(0)
  54. #define __P110 __pgprot(0)
  55. #define __P111 __pgprot(0)
  56.  
  57. #define __S000 __pgprot(0)
  58. #define __S001 __pgprot(0)
  59. #define __S010 __pgprot(0)
  60. #define __S011 __pgprot(0)
  61. #define __S100 __pgprot(0)
  62. #define __S101 __pgprot(0)
  63. #define __S110 __pgprot(0)
  64. #define __S111 __pgprot(0)
  65.  
  66. extern unsigned long _page_cachable_default;
  67.  
  68. /*
  69.  * ZERO_PAGE is a global shared page that is always zero; used
  70.  * for zero-mapped memory areas etc..
  71.  */
  72.  
  73. extern unsigned long empty_zero_page;
  74. extern unsigned long zero_page_mask;
  75.  
  76. #define ZERO_PAGE(vaddr) \
  77.     (virt_to_page((void *)(empty_zero_page + (((unsigned long)(vaddr)) & zero_page_mask))))
  78.  
  79. extern void paging_init(void);
  80.  
  81. /*
  82.  * Conversion functions: convert a page and protection to a page entry,
  83.  * and a page entry and page directory to the page they refer to.
  84.  */
  85. #define pmd_phys(pmd)        virt_to_phys((void *)pmd_val(pmd))
  86. #define pmd_page(pmd)        (pfn_to_page(pmd_phys(pmd) >> PAGE_SHIFT))
  87. #define pmd_page_vaddr(pmd)    pmd_val(pmd)
  88.  
  89. #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
  90.  
  91. #define pte_none(pte)        (!(((pte).pte_low | (pte).pte_high) & ~_PAGE_GLOBAL))
  92. #define pte_present(pte)    ((pte).pte_low & _PAGE_PRESENT)
  93.  
  94. static inline void set_pte(pte_t *ptep, pte_t pte)
  95. {
  96.     ptep->pte_high = pte.pte_high;
  97.     smp_wmb();
  98.     ptep->pte_low = pte.pte_low;
  99.     //printk("pte_high %x pte_low %x\n", ptep->pte_high, ptep->pte_low);
  100.  
  101.     if (pte.pte_low & _PAGE_GLOBAL) {
  102.         pte_t *buddy = ptep_buddy(ptep);
  103.         /*
  104.          * Make sure the buddy is global too (if it's !none,
  105.          * it better already be global)
  106.          */
  107.         if (pte_none(*buddy)) {
  108.             buddy->pte_low  |= _PAGE_GLOBAL;
  109.             buddy->pte_high |= _PAGE_GLOBAL;
  110.         }
  111.     }
  112. }
  113. #define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval)
  114.  
  115. static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
  116. {
  117.     pte_t null = __pte(0);
  118.  
  119.     /* Preserve global status for the pair */
  120.     if (ptep_buddy(ptep)->pte_low & _PAGE_GLOBAL)
  121.         null.pte_low = null.pte_high = _PAGE_GLOBAL;
  122.  
  123.     set_pte_at(mm, addr, ptep, null);
  124. }
  125. #else
  126.  
  127. #define pte_none(pte)        (!(pte_val(pte) & ~_PAGE_GLOBAL))
  128. #define pte_present(pte)    (pte_val(pte) & _PAGE_PRESENT)
  129.  
  130. /*
  131.  * Certain architectures need to do special things when pte's
  132.  * within a page table are directly modified.  Thus, the following
  133.  * hook is made available.
  134.  */
  135. static inline void set_pte(pte_t *ptep, pte_t pteval)
  136. {
  137.     *ptep = pteval;
  138. #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX)
  139.     if (pte_val(pteval) & _PAGE_GLOBAL) {
  140.         pte_t *buddy = ptep_buddy(ptep);
  141.         /*
  142.          * Make sure the buddy is global too (if it's !none,
  143.          * it better already be global)
  144.          */
  145.         if (pte_none(*buddy))
  146.             pte_val(*buddy) = pte_val(*buddy) | _PAGE_GLOBAL;
  147.     }
  148. #endif
  149. }
  150. #define set_pte_at(mm, addr, ptep, pteval) set_pte(ptep, pteval)
  151.  
  152. static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
  153. {
  154. #if !defined(CONFIG_CPU_R3000) && !defined(CONFIG_CPU_TX39XX)
  155.     /* Preserve global status for the pair */
  156.     if (pte_val(*ptep_buddy(ptep)) & _PAGE_GLOBAL)
  157.         set_pte_at(mm, addr, ptep, __pte(_PAGE_GLOBAL));
  158.     else
  159. #endif
  160.         set_pte_at(mm, addr, ptep, __pte(0));
  161. }
  162. #endif
  163.  
  164. /*
  165.  * (pmds are folded into puds so this doesn't get actually called,
  166.  * but the define is needed for a generic inline function.)
  167.  */
  168. #define set_pmd(pmdptr, pmdval) do { *(pmdptr) = (pmdval); } while(0)
  169.  
  170. #ifdef CONFIG_64BIT
  171. /*
  172.  * (puds are folded into pgds so this doesn't get actually called,
  173.  * but the define is needed for a generic inline function.)
  174.  */
  175. #define set_pud(pudptr, pudval) do { *(pudptr) = (pudval); } while(0)
  176. #endif
  177.  
  178. #define PGD_T_LOG2    (__builtin_ffs(sizeof(pgd_t)) - 1)
  179. #define PMD_T_LOG2    (__builtin_ffs(sizeof(pmd_t)) - 1)
  180. #define PTE_T_LOG2    (__builtin_ffs(sizeof(pte_t)) - 1)
  181.  
  182. /*
  183.  * We used to declare this array with size but gcc 3.3 and older are not able
  184.  * to find that this expression is a constant, so the size is dropped.
  185.  */
  186. extern pgd_t swapper_pg_dir[];
  187.  
  188. /*
  189.  * The following only work if pte_present() is true.
  190.  * Undefined behaviour if not..
  191.  */
  192. #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
  193. static inline int pte_write(pte_t pte)    { return pte.pte_low & _PAGE_WRITE; }
  194. static inline int pte_dirty(pte_t pte)    { return pte.pte_low & _PAGE_MODIFIED; }
  195. static inline int pte_young(pte_t pte)    { return pte.pte_low & _PAGE_ACCESSED; }
  196. static inline int pte_file(pte_t pte)    { return pte.pte_low & _PAGE_FILE; }
  197.  
  198. static inline pte_t pte_wrprotect(pte_t pte)
  199. {
  200.     pte.pte_low  &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
  201.     pte.pte_high &= ~_PAGE_SILENT_WRITE;
  202.     return pte;
  203. }
  204.  
  205. static inline pte_t pte_mkclean(pte_t pte)
  206. {
  207.     pte.pte_low  &= ~(_PAGE_MODIFIED | _PAGE_SILENT_WRITE);
  208.     pte.pte_high &= ~_PAGE_SILENT_WRITE;
  209.     return pte;
  210. }
  211.  
  212. static inline pte_t pte_mkold(pte_t pte)
  213. {
  214.     pte.pte_low  &= ~(_PAGE_ACCESSED | _PAGE_SILENT_READ);
  215.     pte.pte_high &= ~_PAGE_SILENT_READ;
  216.     return pte;
  217. }
  218.  
  219. static inline pte_t pte_mkwrite(pte_t pte)
  220. {
  221.     pte.pte_low |= _PAGE_WRITE;
  222.     if (pte.pte_low & _PAGE_MODIFIED) {
  223.         pte.pte_low  |= _PAGE_SILENT_WRITE;
  224.         pte.pte_high |= _PAGE_SILENT_WRITE;
  225.     }
  226.     return pte;
  227. }
  228.  
  229. static inline pte_t pte_mkdirty(pte_t pte)
  230. {
  231.     pte.pte_low |= _PAGE_MODIFIED;
  232.     if (pte.pte_low & _PAGE_WRITE) {
  233.         pte.pte_low  |= _PAGE_SILENT_WRITE;
  234.         pte.pte_high |= _PAGE_SILENT_WRITE;
  235.     }
  236.     return pte;
  237. }
  238.  
  239. static inline pte_t pte_mkyoung(pte_t pte)
  240. {
  241.     pte.pte_low |= _PAGE_ACCESSED;
  242.     if (pte.pte_low & _PAGE_READ) {
  243.         pte.pte_low  |= _PAGE_SILENT_READ;
  244.         pte.pte_high |= _PAGE_SILENT_READ;
  245.     }
  246.     return pte;
  247. }
  248. #else
  249. static inline int pte_write(pte_t pte)    { return pte_val(pte) & _PAGE_WRITE; }
  250. static inline int pte_dirty(pte_t pte)    { return pte_val(pte) & _PAGE_MODIFIED; }
  251. static inline int pte_young(pte_t pte)    { return pte_val(pte) & _PAGE_ACCESSED; }
  252. static inline int pte_file(pte_t pte)    { return pte_val(pte) & _PAGE_FILE; }
  253.  
  254. static inline pte_t pte_wrprotect(pte_t pte)
  255. {
  256.     pte_val(pte) &= ~(_PAGE_WRITE | _PAGE_SILENT_WRITE);
  257.     return pte;
  258. }
  259.  
  260. static inline pte_t pte_mkclean(pte_t pte)
  261. {
  262.     pte_val(pte) &= ~(_PAGE_MODIFIED|_PAGE_SILENT_WRITE);
  263.     return pte;
  264. }
  265.  
  266. static inline pte_t pte_mkold(pte_t pte)
  267. {
  268.     pte_val(pte) &= ~(_PAGE_ACCESSED|_PAGE_SILENT_READ);
  269.     return pte;
  270. }
  271.  
  272. static inline pte_t pte_mkwrite(pte_t pte)
  273. {
  274.     pte_val(pte) |= _PAGE_WRITE;
  275.     if (pte_val(pte) & _PAGE_MODIFIED)
  276.         pte_val(pte) |= _PAGE_SILENT_WRITE;
  277.     return pte;
  278. }
  279.  
  280. static inline pte_t pte_mkdirty(pte_t pte)
  281. {
  282.     pte_val(pte) |= _PAGE_MODIFIED;
  283.     if (pte_val(pte) & _PAGE_WRITE)
  284.         pte_val(pte) |= _PAGE_SILENT_WRITE;
  285.     return pte;
  286. }
  287.  
  288. static inline pte_t pte_mkyoung(pte_t pte)
  289. {
  290.     pte_val(pte) |= _PAGE_ACCESSED;
  291.     if (pte_val(pte) & _PAGE_READ)
  292.         pte_val(pte) |= _PAGE_SILENT_READ;
  293.     return pte;
  294. }
  295. #endif
  296. static inline int pte_special(pte_t pte)    { return 0; }
  297. static inline pte_t pte_mkspecial(pte_t pte)    { return pte; }
  298.  
  299. /*
  300.  * Macro to make mark a page protection value as "uncacheable".  Note
  301.  * that "protection" is really a misnomer here as the protection value
  302.  * contains the memory attribute bits, dirty bits, and various other
  303.  * bits as well.
  304.  */
  305. #define pgprot_noncached pgprot_noncached
  306.  
  307. static inline pgprot_t pgprot_noncached(pgprot_t _prot)
  308. {
  309.     unsigned long prot = pgprot_val(_prot);
  310.  
  311.     prot = (prot & ~_CACHE_MASK) | _CACHE_UNCACHED;
  312.  
  313.     return __pgprot(prot);
  314. }
  315.  
  316. /*
  317.  * Conversion functions: convert a page and protection to a page entry,
  318.  * and a page entry and page directory to the page they refer to.
  319.  */
  320. #define mk_pte(page, pgprot)    pfn_pte(page_to_pfn(page), (pgprot))
  321.  
  322. #if defined(CONFIG_64BIT_PHYS_ADDR) && defined(CONFIG_CPU_MIPS32)
  323. static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  324. {
  325.     pte.pte_low  &= _PAGE_CHG_MASK;
  326.     pte.pte_high &= ~0x3f;
  327.     pte.pte_low  |= pgprot_val(newprot);
  328.     pte.pte_high |= pgprot_val(newprot) & 0x3f;
  329.     return pte;
  330. }
  331. #else
  332. static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  333. {
  334.     return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot));
  335. }
  336. #endif
  337.  
  338.  
  339. extern void __update_tlb(struct vm_area_struct *vma, unsigned long address,
  340.     pte_t pte);
  341. extern void __update_cache(struct vm_area_struct *vma, unsigned long address,
  342.     pte_t pte);
  343.  
  344. static inline void update_mmu_cache(struct vm_area_struct *vma,
  345.     unsigned long address, pte_t pte)
  346. {
  347.     __update_tlb(vma, address, pte);
  348.     __update_cache(vma, address, pte);
  349. }
  350.  
  351. #define kern_addr_valid(addr)    (1)
  352.  
  353. #ifdef CONFIG_64BIT_PHYS_ADDR
  354. extern int remap_pfn_range(struct vm_area_struct *vma, unsigned long from, unsigned long pfn, unsigned long size, pgprot_t prot);
  355.  
  356. static inline int io_remap_pfn_range(struct vm_area_struct *vma,
  357.         unsigned long vaddr,
  358.         unsigned long pfn,
  359.         unsigned long size,
  360.         pgprot_t prot)
  361. {
  362.     phys_t phys_addr_high = fixup_bigphys_addr(pfn << PAGE_SHIFT, size);
  363.     return remap_pfn_range(vma, vaddr, phys_addr_high >> PAGE_SHIFT, size, prot);
  364. }
  365. #else
  366. #define io_remap_pfn_range(vma, vaddr, pfn, size, prot)        \
  367.         remap_pfn_range(vma, vaddr, pfn, size, prot)
  368. #endif
  369.  
  370. #include <asm-generic/pgtable.h>
  371.  
  372. /*
  373.  * We provide our own get_unmapped area to cope with the virtual aliasing
  374.  * constraints placed on us by the cache architecture.
  375.  */
  376. #define HAVE_ARCH_UNMAPPED_AREA
  377.  
  378. /*
  379.  * No page table caches to initialise
  380.  */
  381. #define pgtable_cache_init()    do { } while (0)
  382.  
  383. #endif /* _ASM_PGTABLE_H */
  384.